Questions
12 of 12
1A client gets a dimension-mismatch error when inserting a point. What are the most common root causes?
2A filter query that should return results returns an empty list. What would you check first?
3Why might a collection created without specifying a distance metric or vector size fail immediately, and what does that tell you about how Qdrant treats collection configuration?
4What causes a 'collection not found' error immediately after a collection was reportedly created successfully in a distributed cluster?
5Search results seem semantically wrong even though the embedding model is known to work well. What layers would you check to isolate the problem?
6Recall dropped noticeably after enabling quantization. How would you determine whether the quantization configuration or the rescoring settings are the cause?
7A previously fast query has become slow after months of continuous upserts and deletes, with no configuration changes. What's the most likely explanation?
8How would you distinguish a latency problem caused by disk I/O from one caused by CPU-bound distance computation?
9One node in a three-node Qdrant cluster crashes. What happens to reads and writes for shards that had a replica on that node?
10After a crashed node recovers and rejoins the cluster, how does it catch up on writes it missed?
11What symptoms would indicate a 'split-brain' style problem in a distributed Qdrant cluster, and how does the Raft-based consensus layer prevent it?
12What's your recovery plan if an entire Qdrant cluster is lost (e.g., all nodes' disks fail) and you only have periodic snapshots?
12 / 12

What's your recovery plan if an entire Qdrant cluster is lost (e.g., all nodes' disks fail) and you only have periodic snapshots?

Restore from the most recent snapshot, accept the RPO, and rebuild the cluster

The recovery plan starts with a clear statement of the recovery point objective (RPO): the amount of data you are willing to lose. With periodic snapshots, the RPO is bounded by the snapshot interval - if you snapshot every hour, you can lose up to an hour of writes. The first step is to identify the most recent successful snapshot for each collection, verify its integrity, and understand what data it contains. The second step is to provision a new cluster with the same or better capacity as the original, with the same collection configuration. The third step is to restore each collection from its snapshot, in parallel if possible, and then re-establish replication and consistency. The fourth step is to replay any writes that occurred after the snapshot, if you have a separate write-ahead log or an upstream source of truth - if you do not, those writes are lost. The fifth step is to validate the restored data: check point counts, run a set of known queries and verify the expected results, and confirm that all indexes and payload schemas are present.

The mechanism of snapshot restore in Qdrant is that a snapshot captures the state of a collection at a point in time, including segments, indexes, and payload. Restoring a snapshot creates a collection with that state. Snapshots are stored as files, either locally or in an object store if configured, and can be downloaded and restored via the API or the CLI. The critical operational details are: snapshots must be stored outside the cluster (in an object store like S3, GCS, or Azure Blob) because if they are only on the cluster's disks, they are lost when the disks fail; the restore process requires a running Qdrant instance to receive the snapshot; and the restore is a collection-level operation, so the cluster must be provisioned and running before the restore can begin. The recovery time objective (RTO) is therefore the sum of: time to provision the cluster, time to download the snapshot, time to restore it, time to rebuild indexes if needed, and time to validate. For large collections, the download and restore can take hours, which is why the RPO and RTO must be planned together and tested.

  1. 1

    RPO: determined by snapshot interval; an hourly snapshot means up to an hour of lost writes.

  2. 2

    RTO: provisioning time + download time + restore time + validation time.

  3. 3

    Snapshot storage: must be outside the cluster, in durable object storage.

  4. 4

    Restore: collection-level; requires a running Qdrant instance.

  5. 5

    Validation: point counts, sample queries, payload schemas, indexes.

  6. 6

    Replay: if you have a separate WAL or upstream source of truth, replay writes after the snapshot.

  7. 7

    Testing: restore drills should be run periodically to validate RPO, RTO, and the procedure.

The trade-off is between snapshot frequency and storage cost. Frequent snapshots reduce RPO but consume more storage and add load to the cluster during snapshot creation. Snapshot creation itself has a cost: it reads the collection's data and writes it to storage, which competes with queries. The right frequency depends on how much data loss is acceptable and how much storage and network bandwidth you have. The common mistake is to store snapshots only on the cluster's own disks, which means they are lost in exactly the scenario you are trying to protect against. The second mistake is to never test the restore procedure, so the first real restore happens during an incident and takes much longer than expected because of unexpected issues. The third mistake is to forget the metadata: the collection configuration, the payload schemas, the aliases, and the shard layout are not part of the snapshot, so you must restore them separately or recreate them from your deployment automation. The fourth mistake is to assume the snapshot is a complete backup - it is a point-in-time copy, and if writes occurred between the snapshot and the failure, those writes are gone unless you have another source. Version note: the snapshot format, the storage options, and the API for creating and restoring snapshots have changed across Qdrant releases. If your recovery plan depends on snapshots, verify the exact commands and their behavior on your version, and test the full restore path end to end.

javascript

Version-dependent: the snapshot format and the restore API have changed across Qdrant releases. In some versions, snapshots can be uploaded via the API; in others, they must be placed in a specific directory. The ability to snapshot the entire cluster versus individual collections has also evolved. If your recovery plan depends on snapshots, verify the exact procedure on your version and run a restore drill before you need it in production.

Difficulty: 8/10
Topics: Disaster Recovery, Snapshots, Backup

Scenario Questions

0-2 years experience
  1. 1

    You take daily snapshots and the cluster fails at 3pm. Explain the RPO and what data would be lost.

  2. 2

    A teammate says the snapshots are on the cluster's disks so recovery will be easy. Explain the problem with that plan.

2-5 years experience
  1. 1

    You need to restore a 50M-point collection from a snapshot. Estimate the RTO and describe how you would reduce it.

  2. 2

    You run a restore drill and it takes much longer than expected. Describe the bottlenecks you would look for and how you would address them.

5-8 years experience
  1. 1

    Design a backup strategy for a Qdrant deployment with a 15-minute RPO and a 1-hour RTO. Specify the snapshot frequency, the storage, the restore automation, and the validation.

  2. 2

    You need to restore a cluster that hosted 20 collections with different configurations and replication factors. Describe the automated procedure and how you would validate it.

8+ years experience
  1. 1

    You are designing a disaster recovery architecture for a multi-region Qdrant deployment with a 99.99% availability target. Describe the backup strategy, the failover procedure, and how you validate the RPO and RTO.

  2. 2

    An entire region is lost and you must restore service in another region. Describe the plan, the assumptions, the dependencies, and the communication plan for stakeholders.

Follow-up Questions

  • How would you reduce the RPO below the snapshot interval without sacrificing the simplicity of periodic snapshots?
  • What would you include in a restore validation checklist to be confident the cluster is fully recovered before returning it to production?